In recent years, Business Process Management (BPM) engines have become increasingly common for the implementation of business logic rules within backend systems in a variety of domains. Such domains include, for instance, online vending machines such as content download servers, browsing servers such as portals and mobile portals, rating, charging and billing servers,
Traditionally, business processes are implemented like any other programmed application, by using classical programming languages implemented by computer programmers. However, the nature of business processes is that they evolve and change frequently as the associated business requirements change and evolve. Therefore, engines that enable representing the business processes as flow charts, including a user-friendly graphical user interface (GUI) for authoring and editing these flow charts, have been introduced. Such systems produce an executable form of the flow drawn by the human writer and provide a runtime environment in which this executable form can execute.
A ubiquitous example of flow-based software development environment is business process execution language (BPEL) based systems. These systems enable authoring flows in a graphic environment. The flows are then compiled into a BPEL language and executed in a BPEL engine. Such systems enable encapsulating the business-logic of a business process, orchestration or application in a readily editable flow diagram which enables easier implementation by modelers or programmers and yields to rapid changes for addressing evolving requirements. This change also enables a common language between the business personnel who define the requirements and the technical personnel who implement them—since the flows are intuitive and descriptive, and has even enabled non programming personnel to implement and modify the programmed business flows as they become more intuitive and readily editable.
A key requirement in many cases is to allow human users to get involved in the business process, in at least one of the steps in the process flow. In order to accomplish this, the flow-based language should have the capability of presenting user-interaction (hereinafter: UI) dialogs and receiving the user-response. The user response is then used in the remainder of the flow for making decisions or for passing or storing information to external systems. In standard Business Process Management (BPM), BPEL and similar systems, user interaction is modeled as work items that are sent to users, for example via e-mail or other work list management GUI. Consequently, from the user point of view, the interaction is asynchronous.
Some user interactions are interleaved within a synchronous channel interaction that the human user already uses. For example, a download server receives a user-request for downloading a content item while browsing the service provider (mobile or web) portal. The server, according to the business process, must receive confirmation from the user for the charge. Hence the server may present the user with a dialog such as: “The item you have requested costs 50 cents—will you accept the charges? Yes/No”; the flow must then receive the user-response and, conditioned on that response, either deliver the item to the user or cancel the transaction.
In the aforementioned basic scenario, two actions must be executed in the underlying runtime implementation of the business logic. The first action is presenting a UI to the user and the second action is receiving a user input event. Most modern UI implementations with which users interact (not necessarily in relation to the process flow) are request-response type systems, in which the user-response is an asynchronous event which is unrelated to the UI presentation event. The most obvious example being Web-based GUI's, in which the UI is presented to the user by sending a markup page to the user-agent, and the subsequent response is received as a seemingly unrelated HTTP event received from the user-agent with a URL and parameters. Other current UI systems are also asynchronous in nature and posses the same request/response type process.
A further complication of the required underlying processing stems from two facts: first, the user interaction dialog does not necessarily include just a single page; e.g. in the above example, as part of accepting the charges, a user-authentication screen may be presented requesting the user to enter a PIN code to verify his/her identity.
The flow engine which implements the business-process related UI dialogs which intervene within the user's UI session may preferably not be the same server which implements the previous and subsequent UI's. E.g. in the above example, the advice of charge user-interaction may be generated and handled by the flow engine, while the preceding UI's that describe the vended items and the subsequent screens (or content response) which deliver the purchased item are handled by a download server—implemented on a separate server using a different technology.
The standard human interaction implemented in business process engines is asynchronous by nature and is task-oriented from the point of view of the user. In principle, it is possible for a business process management engines to provide intervening synchronous UI capabilities. However, the asynchronous nature of the underlying runtime events forces the flow writer to be aware of the various underlying events comprising the interaction. The flow writer must handle the correlation between the server response which is the user dialog presentation sent to the end-user, and the ensuing client request which is the user response to such UI.
In presently available flow-based software development environments, the implementation of the UI dialog as a pair of actions should be exposed to the UI management application developer. The responsibility for handling the correlation between the presented UI and subsequent response is on the UI developer. The UI developer must therefore obtain or generate a unique ID for the UI instance (the same UI can be presented to multiple users simultaneously) and for each response button within the UI screen or page—he or she must then encode this ID within the response for later correlation.
The abovementioned solution for dealing with asynchronous UI is cumbersome and error prone. It would be therefore advantageous to have a method and a system that represents asynchronous interactions into a single synchronous action, and providing an underlying implementation which supports this representation.